<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>

</body>
<script>
    // 基本数据类型
    // string number boolean null undefind  object(array)
    // ES新增 symbol bigInt (Map Set)

    // 运算符
    // 算术运算符  * / %  大于  + -
    // 关系运算符  > >= < <=  大于  == != === !==
    // 逻辑运算符  ! 大于 && 大于  ||
    // 三元运算符: ? :
    // 赋值运算符: = += -= *= /= %=    ++ --

    // 运算符的优先级
    // ()  [] .  > ! ++ -- typeof > 算术运算符 > 关系运算符 >  逻辑运算符(!) > 三元运算符 >  赋值运算符(++ --)


    // 强制类型转换
    // String()  Number()  Boolean()
    // parseInt()  parseFloat()

    // string number boolean null undefind

    // String()  强制转字符串
    // console.log(1, String("hello"));
    // console.log(1, String(100));
    // console.log(1, String(true));
    // console.log(1, String(null));
    // console.log(1, String(undefined));

    // Number()  强制转数字 (将其他类型转化为数字)
    // 非纯数字类型的字符串 => NaN
    // 纯数字类型的字符串 => 数字   ""=>0  " " => 0

    // true => 1   false => 0

    // null => 0   undefined => NaN

    // console.log(1, Number("hello"));  // NaN
    // console.log(1, Number("100"));  // 100
    // console.log(1, Number(""));  // 0
    // console.log(1, Number(" "));  // 0

    // console.log(1, Number(100));

    // console.log(1, Number(true)); // 1

    // console.log(1, Number(null));
    // console.log(1, Number(undefined));

    // Boolean() 强制转布尔值 (将其他类型转化为布尔值)

    // console.log(Boolean("")); //false
    // console.log(Boolean(0)); //false
    // console.log(Boolean(NaN)); //false
    // console.log(Boolean(false)); //false
    // console.log(Boolean(null)); //false
    // console.log(Boolean(undefined)); //false

    // console.log(Boolean(" ")); // true

    // if(表达式){}
    // while(表达式){}
    // 表达式1? 表达式2:表达式3

    // if (NaN) {
    //     console.log(true);
    // } else {
    //     console.log(false);
    // }


    // 隐式类型转换 =>  浏览器默认执行的转化机制
    // string number boolean null undefind

    // 1. 算术运算符的隐式类型转换   + - * / %
    // a. 字符串 遇到 + 会拼接形成新的字符串
    // console.log("100" + 1);
    // console.log(1 + "100");

    // b. 字符串遇到 - * / % 会先隐式转数字,再进行运算
    // console.log("100px" - 1); // NaN
    // console.log("100" - 1); // 99
    // console.log("100" * 2); // 200

    // c. 布尔值遇到算术运算符  先隐式转数字,再进行运算
    //  true => 1  false => 0

    // d. null undefined遇到算术运算符  先隐式转数字,再进行运算
    //  null => 0  undefined => NaN


    // 2. 关系运算符的隐式类型转换  > >= < <=  == !=  (=== !==除外)
    // a. 字符串 布尔值 和数字比较时,会先转化为数字再比较
    // console.log("10" > 5); // true ("10" => 10 > 5)
    // console.log(true > 5); // false (true => 1 > 5)
    // console.log("10" > true); // true
    // console.log(true == 1); // true
    // console.log(true == 2);  // false (true => 1 == 2)

    // b. 字符串和字符串比较时, 此时会一次按顺序比较字符对应的ASCII码 (第一个不同就比第一个,第一个相同就比第二个 以此类推)
    // console.log("5" > "3");  // true ("5" => 53  "3" => 51  => 53 > 51)
    // console.log("15" > "3"); // false ("1" => 49  3 => 51   49 > 51)
    // console.log("A" > "5");  // true
    // console.log("A" < "a");  // true

    // c. null 和 undefined
    //   I: null 和 undefined 遇到 > >= < <= 先转数字再比较
    //   II: null 和 undefined 遇到 == != 不会发生转化 => 直接比较 => 没有可比性

    // console.log(null >= 0);  // true (true => 0 >= 0)
    // console.log(undefined >= 0);  // false (undefined => NaN >= 0)

    // console.log(null == 0); // false
    // console.log(undefined == 0); // false

    // d. null 和 undefined 在数值上是相等的
    // console.log(null == undefined); // 在数值上是相等的
    // console.log(null === undefined); // 在数值上是相等的,类型不相等

    // f: NaN和任何值都不相等
    // console.log(NaN == NaN); // false

    // 3. 逻辑运算符的隐式类型转换 (!)
    //  如果!后的表达式不是布尔值 => 先隐式将表达式转布尔值 再取反

    // console.log(!true);  // false
    // console.log(!false);  // true

    // console.log(!1);  // false  (1 => true  取反 => false)
    // console.log(!"");  // true  ("" => false  取反 => true)

    // console.log(!!1);  // true  (1 => true  取反之后再取反)
    // console.log(!!"");  // false  ("" => false  取反后再取反)

    // Boolean(1);
    // !!1;

    // 4. 算术运算符的隐式类型转换
    // ++ --   如果++ -- 的是非数字类型 => 先将其他类型隐式转化为数字类型 在自增/自减

    // var a = "10";
    // a++;
    // console.log(a);

    console.log(!1 == true);  // !1 = > false  == true => false










</script>

</html>